# Import Library (Satu-satunya sel kode dalam template ini)
import numpy as np
import matplotlib.pyplot as plt
import librosa
import soundfile as sf
from PIL import Image
import cv2
from IPython.display import Audio, HTML, display
import os

# Set matplotlib untuk menampilkan plot inline
%matplotlib inline

# Tampilkan versi library untuk dokumentasi
print("Library versions:")
print(f"NumPy: {np.__version__}")
print(f"Matplotlib: {plt.matplotlib.__version__}")
print(f"Librosa: {librosa.__version__}")
print(f"OpenCV: {cv2.__version__}")

# Tambahkan import lain jika diperlukan saat mengerjakan tugas

Library versions:
NumPy: 2.2.5
Matplotlib: 3.10.6
Librosa: 0.11.0
OpenCV: 4.10.0

# Muat file audio dan tampilkan metadata dasar
audio_path = os.path.join('data', 'rain&thunder.wav')

# Membaca audio (y: array amplitudo, sr: sample rate)
y, sr = librosa.load(audio_path, sr=None, mono=False)  # mono=False agar bisa deteksi jumlah kanal

# Jika y 1D: mono, jika 2D: stereo/multi-channel
if y.ndim == 1:
  num_channels = 1
  channel_info = 'Mono'
  total_samples = y.shape[0]
else:
  num_channels = y.shape[0]
  channel_info = f'Stereo ({num_channels} channels)' if num_channels == 2 else f'{num_channels} channels'
  total_samples = y.shape[1]

duration_sec = total_samples / sr

print(f"Path file      : {audio_path}")
print(f"Sample rate    : {sr} Hz")
print(f"Durasi         : {duration_sec:.2f} detik")
print(f"Jumlah kanal   : {channel_info}")
print(f"Total sampel   : {total_samples}")

Path file      : data\rain&thunder.wav
Sample rate    : 96000 Hz
Durasi         : 27.07 detik
Jumlah kanal   : Stereo (2 channels)
Total sampel   : 2598291

# Plot waveform audio untuk masing-masing kanal (stereo)
fig, axs = plt.subplots(num_channels, 1, figsize=(12, 4 * num_channels), sharex=True)

# Buat array waktu (detik)
times = np.arange(total_samples) / sr

channel_names = ['Kanal Kiri (Left)', 'Kanal Kanan (Right)'] if num_channels == 2 else ['Mono']

for i in range(num_channels):
  ax = axs[i] if num_channels > 1 else axs
  ax.plot(times, y[i] if num_channels > 1 else y, color='C0')
  ax.set_ylabel('Amplitudo')
  ax.set_title(f'Waveform Audio - {channel_names[i]}')
  ax.grid(True)

axs[-1].set_xlabel('Waktu (detik)')
plt.tight_layout()
plt.show()

# Tampilkan pemutar audio
display(Audio(audio_path))

# Parameter STFT sesuai instruksi
n_fft = 1024
hop_length = 256

# ========== SPECTROGRAM 1: Linear Scale (Hz) ==========
print("Membuat Spectrogram dengan skala linear...")

# Buat plot untuk setiap kanal
fig1, axs1 = plt.subplots(num_channels, 1, figsize=(12, 4 * num_channels))

# Jika hanya 1 kanal, axs bukan array
if num_channels == 1:
    axs1 = [axs1]

for i in range(num_channels):
    # Ambil data audio per kanal
    if num_channels == 1:
        audio_data = y
    else:
        audio_data = y[i]
   
    # Hitung STFT
    stft_result = librosa.stft(audio_data, n_fft=n_fft, hop_length=hop_length)
   
    # Konversi ke magnitude dalam dB
    magnitude_db = librosa.amplitude_to_db(np.abs(stft_result), ref=np.max)
   
    # Tampilkan spectrogram
    img1 = librosa.display.specshow(
        magnitude_db,
        sr=sr,
        hop_length=hop_length,
        x_axis='time',    # Label sumbu X: waktu (detik)
        y_axis='hz',      # Label sumbu Y: frekuensi (Hz)
        fmax=10000,       # Batasi frekuensi maksimum ke 10 kHz
        ax=axs1[i]
    )
   
    # Set title dan label
    axs1[i].set_title(f'Spectrogram STFT Linear - {channel_names[i]}')
    axs1[i].set_xlabel('Waktu (detik)')
    axs1[i].set_ylabel('Frekuensi (Hz)')
   
    # Tambahkan colorbar
    cbar1 = fig1.colorbar(img1, ax=axs1[i], format='%+2.0f dB')
    cbar1.set_label('Magnitude (dB)')

# Atur layout dan tampilkan
plt.tight_layout()
plt.show()


# ========== SPECTROGRAM 2: Logarithmic Scale ==========
print("Membuat Spectrogram dengan skala logaritmik...")

# Buat plot kedua dengan skala logaritmik
fig2, axs2 = plt.subplots(num_channels, 1, figsize=(12, 4 * num_channels), sharex=True)

# Jika hanya 1 kanal, axs bukan array
if num_channels == 1:
    axs2 = [axs2]

for idx in range(num_channels):
    # Ambil sinyal per kanal
    y_channel = y[idx] if num_channels > 1 else y
   
    # STFT (menggunakan parameter yang sama)
    D = librosa.stft(y_channel, n_fft=n_fft, hop_length=hop_length)
    S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)
   
    # Tampilkan spectrogram dengan skala log untuk sumbu y
    img2 = librosa.display.specshow(
        S_db,
        sr=sr,
        hop_length=hop_length,
        x_axis='time',
        y_axis='log',    # Skala logaritmik untuk frekuensi
        ax=axs2[idx],
        fmax=sr//2,      # Batasi frekuensi maksimum (Nyquist frequency)
        vmin=-80,        # Batasi range dB minimum untuk kontras yang lebih baik
        vmax=0           # Batasi range dB maksimum
    )
   
    axs2[idx].set_title(f"Spectrogram STFT Log-dB - {channel_names[idx]}")
    axs2[idx].set_ylabel("Frekuensi (Hz)")
    axs2[idx].set_xlabel("Waktu (detik)")
   
    # Colorbar dengan range yang lebih terbatas
    cbar2 = fig2.colorbar(img2, ax=axs2[idx], format="%+2.0f dB")
    cbar2.set_label('Magnitude (dB)')

plt.tight_layout()
plt.show()


# ========== INFORMASI PARAMETER STFT ==========
print(f"\nParameter STFT yang digunakan:")
print(f"- n_fft: {n_fft}")
print(f"- hop_length: {hop_length}")
print(f"- Resolusi frekuensi: {sr/n_fft:.2f} Hz")
print(f"- Resolusi waktu: {hop_length/sr*1000:.2f} ms")
print(f"- Jumlah kanal: {num_channels}")
print(f"\nDua spectrogram telah dibuat:")
print(f"1. Spectrogram Linear: Skala frekuensi linear (Hz), fmax=10kHz")
print(f"2. Spectrogram Logaritmik: Skala frekuensi log, fmax={sr//2}Hz, range dB: -80 to 0")

Membuat Spectrogram dengan skala linear...

Membuat Spectrogram dengan skala logaritmik...

Parameter STFT yang digunakan:
- n_fft: 1024
- hop_length: 256
- Resolusi frekuensi: 93.75 Hz
- Resolusi waktu: 2.67 ms
- Jumlah kanal: 2

Dua spectrogram telah dibuat:
1. Spectrogram Linear: Skala frekuensi linear (Hz), fmax=10kHz
2. Spectrogram Logaritmik: Skala frekuensi log, fmax=48000Hz, range dB: -80 to 0

# Hitung MFCC (menggunakan 13 koefisien pertama, sesuai instruksi)
n_mfcc = 13
mfccs = librosa.feature.mfcc(y=audio_data, sr=sr, n_mfcc=n_mfcc, n_fft=n_fft, hop_length=hop_length)

# Plot MFCC sebagai heatmap
plt.figure(figsize=(14, 6))
img = plt.imshow(mfccs, aspect='auto', origin='lower', 
         interpolation='nearest', cmap='viridis',
         extent=[0, mfccs.shape[1], 1, n_mfcc])

plt.title('MFCC (13 Koefisien Pertama) - Audio "Rain & Thunder"')
plt.xlabel('Frame Waktu')
plt.ylabel('Koefisien MFCC')
cbar = plt.colorbar(img, format='%+2.1f')
cbar.set_label('Magnitudo MFCC (dB)')
plt.yticks(np.arange(1, n_mfcc + 1))
plt.tight_layout()
plt.show()

c:\Users\Naufal Haris\.conda\envs\multimedia_env\lib\site-packages\librosa\feature\spectral.py:2148: UserWarning: Empty filters detected in mel frequency basis. Some channels will produce empty responses. Try increasing your sampling rate (and fmax) or reducing n_mels.
  mel_basis = filters.mel(sr=sr, n_fft=n_fft, **kwargs)

# Baca gambar dengan OpenCV (untuk output BGR)
img_bgr = cv2.imread('data/koentjie.jpg')
# Baca gambar dengan openCV untuk output RGB
img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(8, 6))
plt.imshow(img_rgb)
plt.title('Foto Mendaki Gunung Ratai Bersama Teman-teman')
plt.axis('off')  # Hilangkan axis
plt.show()

# Tampilkan metadata gambar
height, width, channels = img_rgb.shape
dtype = img_rgb.dtype
mem_bytes = img_rgb.nbytes
mem_mb = mem_bytes / (1024 * 1024)

# Menentukan mode warna secara dinamis
if channels == 3:
    mode = "RGB"
elif channels == 4:
    mode = "RGBA" # RGB dengan kanal Alpha (transparansi)
elif channels == 1:
    mode = "Grayscale"
else:
    mode = f"{channels} Kanal" # Untuk mode lain yang tidak umum

# Print hasil
print(f"Dimensi (Height × Width) : {height} × {width}")
print(f"Jumlah kanal             : {channels}")
print(f"Tipe data (dtype)        : {dtype}")
print(f"Mode warna               : {mode}")
print(f"Ukuran file di memori    : {mem_mb:.2f} MB")

Dimensi (Height × Width) : 1600 × 1200
Jumlah kanal             : 3
Tipe data (dtype)        : uint8
Mode warna               : RGB
Ukuran file di memori    : 5.49 MB

# Plot histogram distribusi intensitas untuk channel R, G, B
colors = ['red', 'green', 'blue']
channel_labels = ['Red', 'Green', 'Blue']

plt.figure(figsize=(10, 6))
for i, color in enumerate(colors):
  plt.hist(
    img_rgb[..., i].ravel(),
    bins=256,
    range=(0, 255),
    color=color,
    alpha=0.6,
    label=channel_labels[i]
  )

plt.title('Histogram Distribusi Intensitas Warna (R, G, B)')
plt.xlabel('Intensitas Pixel (0-255)')
plt.ylabel('Frekuensi')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.3)
plt.tight_layout()
plt.show()

# Tentukan path ke file video
video_path = 'data/koentjie.mp4'

# Buka video menggunakan VideoCapture
cap = cv2.VideoCapture(video_path)

# Periksa apakah video berhasil dibuka
if not cap.isOpened():
    print(f"Error: Tidak bisa membuka file video di '{video_path}'")
    sys.exit()

# 1. Resolusi (Width & Height)
# Ambil properti lebar dan tinggi frame, lalu konversi ke integer
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# 2. Frame Rate (fps)
# Ambil properti FPS (Frames Per Second)
fps = cap.get(cv2.CAP_PROP_FPS)

# 3. Jumlah Total Frame
# Ambil properti jumlah total frame dalam video
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# 4. Durasi (detik)
# Hitung durasi dengan membagi total frame dengan fps
# Tambahkan pengecekan untuk menghindari pembagian dengan nol jika fps tidak valid
duration = 0
if fps > 0:
    duration = total_frames / fps
else:
    duration = "Tidak dapat dihitung (FPS = 0)"


# 5. Klasifikasi Resolusi
# Tentukan klasifikasi berdasarkan lebar (width) video
if width >= 3840:
    resolution_class = "4K (Ultra HD)"
elif width >= 2560:
    resolution_class = "QHD (2K)"
elif width >= 1920:
    resolution_class = "Full HD (FHD)"
elif width >= 1280:
    resolution_class = "HD"
else:
    resolution_class = "SD (Standard Definition)"


# --- Tampilkan Hasil Metadata ---
print("===== METADATA VIDEO =====")
print(f"Lokasi File         : {video_path}")
print(f"Resolusi            : {width} × {height} pixels")
print(f"Frame Rate (FPS)    : {fps:.2f} fps")
print(f"Jumlah Total Frame  : {total_frames} frames")
if isinstance(duration, float):
    print(f"Durasi              : {duration:.2f} detik")
else:
    print(f"Durasi              : {duration}")

print(f"Klasifikasi Resolusi: {resolution_class}")

# Jangan lupa untuk melepaskan object capture setelah selesai
cap.release()

===== METADATA VIDEO =====
Lokasi File         : data/koentjie.mp4
Resolusi            : 478 × 850 pixels
Frame Rate (FPS)    : 25.00 fps
Jumlah Total Frame  : 606 frames
Durasi              : 24.24 detik
Klasifikasi Resolusi: SD (Standard Definition)

# Tentukan path ke file video
video_path = 'data/koentjie.mp4'

# Buka video menggunakan VideoCapture
cap = cv2.VideoCapture(video_path)

# Periksa apakah video berhasil dibuka
if not cap.isOpened():
    print(f"Error: Tidak bisa membuka file video di '{video_path}'")
else:
    # Ambil metadata yang diperlukan
    fps = cap.get(cv2.CAP_PROP_FPS)
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    
    print(f"Total frames: {total_frames}, FPS: {fps}")

    # PERBAIKAN: Kurangi frame akhir dengan buffer lebih besar
    frame_akhir_safe = max(0, total_frames - 2)  # Buffer 2 frame dari akhir
    
    # Tentukan indeks dan timestamp untuk setiap frame
    ts_tengah = (total_frames / 2) / fps if fps > 0 else 0
    ts_akhir = frame_akhir_safe / fps if fps > 0 else 0

    frame_info = {
        "Frame Awal": {"index": 0, "timestamp": 0.0},
        "Frame Tengah": {"index": int(total_frames / 2), "timestamp": ts_tengah},
        "Frame Akhir": {"index": frame_akhir_safe, "timestamp": ts_akhir}
    }

    # Siapkan subplot untuk menampilkan 3 gambar
    fig, axes = plt.subplots(1, 3, figsize=(18, 6))
    
    # Loop melalui informasi frame yang sudah kita siapkan
    for i, (title, info) in enumerate(frame_info.items()):
        print(f"Mencoba membaca {title} - Frame #{info['index']}")
        
        # PERBAIKAN: Cek apakah index valid
        if info["index"] >= total_frames:
            print(f"Warning: Index {info['index']} melebihi total frames {total_frames}")
            info["index"] = total_frames - 20  # Fallback ke 20 frame sebelum akhir
        
        # Lompat ke frame yang diinginkan
        success = cap.set(cv2.CAP_PROP_POS_FRAMES, info["index"])
        if not success:
            print(f"Gagal set posisi frame untuk {title}")
            continue
        
        # Baca frame
        ret, frame = cap.read()
        
        if ret and frame is not None:
            # Langkah KRUSIAL: Konversi BGR (OpenCV) -> RGB (Matplotlib)
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            
            # Tampilkan frame di subplot yang sesuai
            axes[i].imshow(frame_rgb)
            
            # Buat judul yang informatif dengan timestamp
            judul = f"{title}\n(Frame #{info['index']}, Detik: {info['timestamp']:.2f}s)"
            axes[i].set_title(judul, fontsize=12)
            
            print(f"✓ Berhasil membaca {title}")
        else:
            print(f"✗ Gagal membaca {title}")
            axes[i].text(0.5, 0.5, f"Gagal membaca\n{title}", 
                        ha='center', va='center', transform=axes[i].transAxes)
            axes[i].set_title(f"Gagal membaca {title}")
        
        # Hilangkan sumbu x dan y untuk tampilan yang lebih bersih
        axes[i].axis('off')

    # Atur layout agar rapi dan tampilkan plot
    plt.tight_layout()
    plt.show()

# Jangan lupa untuk melepaskan object capture setelah selesai
cap.release()

Total frames: 606, FPS: 25.0
Mencoba membaca Frame Awal - Frame #0
✓ Berhasil membaca Frame Awal
Mencoba membaca Frame Tengah - Frame #303
✓ Berhasil membaca Frame Tengah
Mencoba membaca Frame Akhir - Frame #604
✓ Berhasil membaca Frame Akhir

Aspek Penilaian	Bobot	Deskripsi
Kelengkapan	35%	Semua langkah inti dikerjakan sesuai checklist
Kualitas Visualisasi	20%	Judul, label sumbu, colorbar, legend, keterbacaan plot
Analisis & Interpretasi	30%	Kemampuan interpretasi hasil, bukan sekadar output mentah
Kerapihan & Struktur	10%	Markdown jelas, kode modular, dokumentasi baik
Orisinalitas & Penguasaan	5%	Pemahaman saat presentasi acak

Tugas Analisis Multimedia: Audio, Gambar, Video¶

Deskripsi Tugas¶

⚠️ CATATAN PENTING: PRESENTASI ACAK & KEJUJURAN AKADEMIK¶

Petunjuk Umum Pengerjaan¶

📋 Cara Menggunakan Template¶

📊 Standar Visualisasi¶

📂 Struktur Data yang Direkomendasikan¶

⚠️ Larangan¶

🎯 Persiapan Presentasi Acak¶

Checklist Kelengkapan (Centang ✅ saat selesai)¶

🎵 Bagian Audio¶

🖼️ Bagian Gambar¶

📹 Bagian Video¶

📝 Analisis & Dokumentasi¶

Pendahuluan¶

Apa itu Data Multimedia?¶

Tujuan Tugas¶

Cara Kerja¶

Bagian A — Audio¶

A1. Deskripsi Data¶

A2. TODO: Muat & Metadata¶

A3. TODO: Waveform¶

A4. TODO: Spectrogram log-dB¶

A5. TODO: MFCC¶

A6. Analisis Ringkas (Wajib)¶

Bagian B — Gambar¶

B1. Deskripsi Data¶

B2. TODO: Baca & Tampilkan (RGB)¶

B3. TODO: Informasi Dasar¶

B4. TODO: Histogram Warna¶

B5. Analisis Ringkas (Wajib)¶

Bagian C — Video¶

C1. Deskripsi Data¶

C2. TODO: Baca & Metadata¶

C3. TODO: Tampilkan 3 Frame (Awal–Tengah–Akhir)¶

C4. Analisis Ringkas (Wajib)¶

Perbandingan & Kesimpulan¶

Perbandingan Representasi Media¶

Audio (1D - Temporal)¶

Gambar (2D - Spasial)¶

Video (2D + Waktu - Spatio-temporal)¶

Refleksi Pembelajaran¶

3 Poin yang Saya Pelajari:¶

2 Hal yang Masih Membingungkan/Ingin Diperdalam:¶

Sumber Data & Referensi¶

Rubrik Penilaian¶

Distribusi Bobot Penilaian¶

Detail Kriteria Penilaian¶

🏆 Kelengkapan (35%)¶

📊 Kualitas Visualisasi (20%)¶

🧠 Analisis & Interpretasi (30%)¶

📝 Kerapihan & Struktur (10%)¶

🎯 Orisinalitas & Penguasaan (5%)¶

Proporsi Penilaian Total¶

Aturan Kejujuran Akademik¶

📖 Penggunaan Referensi & AI yang Diperbolehkan¶

⚠️ Syarat & Batasan WAJIB¶

❌ Pelanggaran yang Berakibat Nilai 0¶

🎯 Persiapan Presentasi Acak¶

Panduan Pengumpulan¶

📁 Berkas yang Harus Dikumpulkan¶

Wajib:¶

📅 Informasi Pengumpulan¶

✅ Checklist Sebelum Submit¶

Export ke PDF:¶